Jassif Team Institution

CommonJS (Node.js-এ ডিফল্ট)

const os = require('os');

ES Modules (Node.js 14+ or with "type": "module" in package.json)

import os from 'os';
// or
import { arch, platform, cpus } from 'os';

const os = require('os');

// Basic system information
console.log(`OS Platform: ${os.platform()}`);
console.log(`OS Type: ${os.type()}`);
console.log(`OS Release: ${os.release()}`);
console.log(`CPU Architecture: ${os.arch()}`);
console.log(`Hostname: ${os.hostname()}`);

// Memory information
const totalMemGB = (os.totalmem() / (1024 * 1024 * 1024)).toFixed(2);
const freeMemGB = (os.freemem() / (1024 * 1024 * 1024)).toFixed(2);
console.log(`Memory: ${freeMemGB}GB free of ${totalMemGB}GB`);

// User information
const userInfo = os.userInfo();
console.log(`Current User: ${userInfo.username}`);
console.log(`Home Directory: ${os.homedir()}`);

const os = require('os');

// Get CPU architecture
console.log(`CPU Architecture: ${os.arch()}`);

// Common values:
// - 'x64' for 64-bit systems
// - 'arm' for ARM processors
// - 'arm64' for 64-bit ARM
// - 'ia32' for 32-bit x86
// - 'mips' for MIPS processors

const os = require('os');

// Get platform information
const platform = os.platform();
console.log(`Platform: ${platform}`);

// Common values:
// - 'darwin' for macOS
// - 'win32' for Windows (both 32-bit and 64-bit)
// - 'linux' for Linux
// - 'freebsd' for FreeBSD
// - 'openbsd' for OpenBSD

const os = require('os');

// Get OS type
console.log(`OS Type: ${os.type()}`);

// Examples:
// - 'Linux' on Linux
// - 'Darwin' on macOS
// - 'Windows_NT' on Windows

const os = require('os');

// Get OS release information
console.log(`OS Release: ${os.release()}`);

// Examples:
// - '10.0.19044' on Windows 10
// - '21.6.0' on macOS Monterey
// - '5.15.0-46-generic' on Ubuntu

const os = require('os');

// Get kernel version
console.log(`Kernel Version: ${os.version()}`);

// Example output:
// - Windows: 'Windows 10 Enterprise 10.0.19044'
// - Linux: '#49-Ubuntu SMP Tue Aug 2 08:49:28 UTC 2022'
// - macOS: 'Darwin Kernel Version 21.6.0: ...'

const os = require('os');

// Get current user information
const user = os.userInfo();
console.log('User Information:');
console.log(`- Username: ${user.username}`);
console.log(`- User ID: ${user.uid}`);
console.log(`- Group ID: ${user.gid}`);
console.log(`- Home Directory: ${user.homedir}`);

// On Windows, you can also get the user's domain
if (os.platform() === 'win32') {
  console.log(`- Domain: ${user.domain || 'N/A'}`);
}

// Note: user.shell is only available on POSIX platforms
if (user.shell) {
  console.log(`- Default Shell: ${user.shell}`);
}

const os = require('os');
const path = require('path');

// Get the home directory
const homeDir = os.homedir();
console.log(`Home Directory: ${homeDir}`);

// Example: Create a path to a config file in the user's home directory
const configPath = path.join(homeDir, '.myapp', 'config.json');
console.log(`Config file will be saved to: ${configPath}`);

const os = require('os');

// Get the system hostname
const hostname = os.hostname();
console.log(`Hostname: ${hostname}`);

// Example: Use hostname in logging or configuration
console.log(`Server started on ${hostname} at ${new Date().toISOString()}`);

const os = require('os');

// Get the system default temp dir
console.log(`Temporary Directory: ${os.tmpdir()}`);

const os = require('os');

// Get CPU information
const cpus = os.cpus();
console.log(`Number of CPU Cores: ${cpus.length}`);

// Display information about each CPU core
cpus.forEach((cpu, index) => {
  console.log(`\nCPU Core ${index + 1}:`);
  console.log(`- Model: ${cpu.model}`);
  console.log(`- Speed: ${cpu.speed} MHz`);
  console.log('- Times (ms):', {
    user: cpu.times.user,
    nice: cpu.times.nice,
    sys: cpu.times.sys,
    idle: cpu.times.idle,
    irq: cpu.times.irq
  });
});

CPU ব্যবহার গণনা করা হচ্ছে (উদাহরণস্বরূপ, দুটি পরিমাপ প্রয়োজন)

// Calculate total CPU usage (example, requires two measurements)
function calculateCpuUsage(prevCpus) {
  const currentCpus = os.cpus();
  const usage = [];

  for (let i = 0; i < currentCpus.length; i++) {
    const current = currentCpus[i];
    const prev = prevCpus ? prevCpus[i] : { times: { user: 0, nice: 0, sys: 0, idle: 0, irq: 0 } };

    const prevIdle = prev.times.idle;
    const idle = current.times.idle - prevIdle;

    let total = 0;
    for (const type in current.times) {
      total += current.times[type] - (prev.times[type] || 0);
    }

    const usagePercent = ((1 - idle / total) * 100).toFixed(1);
    usage.push(parseFloat(usagePercent));
  }

  return {
    perCore: usage,
    average: (usage.reduce((a, b) => a + b, 0) / usage.length).toFixed(1),
    cpus: currentCpus
  };
}

// Example usage of CPU usage calculation
console.log('\nCPU Usage (requires two measurements):');
const firstMeasure = os.cpus();

// Simulate some CPU work
for (let i = 0; i < 1000000000; i++) {}
const usage = calculateCpuUsage(firstMeasure);
console.log(`Average CPU Usage: ${usage.average}%`);

const os = require('os');

// Format bytes to human-readable format
function formatBytes(bytes, decimals = 2) {
  if (bytes === 0) return '0 Bytes';
  const k = 1024;
  const dm = decimals < 0 ? 0 : decimals;
  const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
  const i = Math.floor(Math.log(bytes) / Math.log(k));
  return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + ' ' + sizes[i];
}

// Get memory information
const totalMem = os.totalmem();
const freeMem = os.freemem();
const usedMem = totalMem - freeMem;
const usagePercent = ((usedMem / totalMem) * 100).toFixed(2);

console.log('Memory Information:');
console.log(`- Total Memory: ${formatBytes(totalMem)}`);
console.log(`- Free Memory: ${formatBytes(freeMem)} (${((freeMem / totalMem) * 100).toFixed(2)}%)`);
console.log(`- Used Memory: ${formatBytes(usedMem)} (${usagePercent}%)`);

// Example: Check if there's enough free memory
const MIN_FREE_MEMORY = 200 * 1024 * 1024; // 200MB
if (freeMem < MIN_FREE_MEMORY) {
  console.warn('Warning: Low on memory!');
} else {
  console.log('System has sufficient memory available');
}

const os = require('os');

// Get load averages
const loadAverages = os.loadavg();
console.log('System Load Averages (1, 5, 15 min):', loadAverages);

// On Linux/Unix, load average represents the average system load over the last 1, 5, and 15 minutes
// The values represent the number of processes in the system run queue
const [oneMin, fiveMin, fifteenMin] = loadAverages;
const cpuCount = os.cpus().length;

console.log(`1-minute load average: ${oneMin.toFixed(2)} (${(oneMin / cpuCount * 100).toFixed(1)}% of ${cpuCount} cores)`);
console.log(`5-minute load average: ${fiveMin.toFixed(2)}`);
console.log(`15-minute load average: ${fifteenMin.toFixed(2)}`);

// Example: Check if system is under heavy load
const isSystemOverloaded = oneMin > cpuCount * 1.5;
if (isSystemOverloaded) {
  console.warn('Warning: System is under heavy load!');
} else {
  console.log('System load is normal');
}

const os = require('os');

// Get network interfaces information
const networkInterfaces = os.networkInterfaces();

console.log('Network Interfaces:');

// Iterate over each network interface
Object.entries(networkInterfaces).forEach(([name, addresses]) => {
  console.log(`\nInterface: ${name}`);
  addresses.forEach((address) => {
    console.log(`- Family: ${address.family}`);
    console.log(`  Address: ${address.address}`);
    console.log(`  Netmask: ${address.netmask}`);
    console.log(`  MAC: ${address.mac || 'N/A'}`);
    console.log(`  Internal: ${address.internal}`);
  });
});

// Example: Find the first non-internal IPv4 address
function getLocalIpAddress() {
  const interfaces = os.networkInterfaces();
  for (const name of Object.keys(interfaces)) {
    for (const iface of interfaces[name]) {
      if (iface.family === 'IPv4' && !iface.internal) {
        return iface.address;
      }
    }
  }
  return '127.0.0.1'; // Fallback to localhost
}

const localIp = getLocalIpAddress();
console.log(`\nLocal IP Address: ${localIp}`);

const os = require('os');

// Get system uptime in seconds
const uptime = os.uptime();
console.log(`System Uptime: ${uptime} seconds`);

// Format uptime in a more readable way
const uptimeDays = Math.floor(uptime / (60 * 60 * 24));
const uptimeHours = Math.floor((uptime % (60 * 60 * 24)) / (60 * 60));
const uptimeMinutes = Math.floor((uptime % (60 * 60)) / 60);
const uptimeSeconds = Math.floor(uptime % 60);

console.log(`System has been running for: ${uptimeDays} days, ${uptimeHours} hours, ${uptimeMinutes} minutes, ${uptimeSeconds} seconds`);

const os = require('os');

// Get all signal constants
console.log('Signal Constants:', os.constants.signals);

// Example: Handle common signals
process.on('SIGINT', () => {
  console.log('Received SIGINT. Performing cleanup...');
  process.exit(0);
});

process.on('SIGTERM', () => {
  console.log('Received SIGTERM. Shutting down gracefully...');
  process.exit(0);
});

console.log('Process is running. Press Ctrl+C to exit.');

const os = require('os');
const fs = require('fs');

// Get the end-of-line marker for the current OS
console.log('End of Line character:', JSON.stringify(os.EOL));

// Example: Write a file with platform-specific line endings
const lines = [
  'First line',
  'Second line',
  'Third line'
];

// Join lines with the correct EOL character
const content = lines.join(os.EOL);
fs.writeFileSync('output.txt', content);
console.log('File written with platform-appropriate line endings');

// Good
const filePath = path.join(os.homedir(), 'app', 'config.json');

// Bad (won't work on Windows)
const badPath = `${os.homedir()}/app/config.json`;

const content = `First Line${os.EOL}Second Line${os.EOL}Third Line`;
fs.writeFileSync('output.txt', content, 'utf8');

const MIN_FREE_MEMORY_MB = 500; // 500MB minimum free memory

function canPerformMemoryIntensiveOperation() {
  const freeMemMB = os.freemem() / (1024 * 1024);
  return freeMemMB > MIN_FREE_MEMORY_MB;
}

if (!canPerformMemoryIntensiveOperation()) {
  console.warn('Not enough free memory to perform this operation');
  // Handle the error appropriately
}

const os = require('os');

function getSystemInfo() {
  const info = {
    os: {
      type: os.type(),
      platform: os.platform(),
      architecture: os.arch(),
      release: os.release(),
      hostname: os.hostname(),
      uptime: formatUptime(os.uptime())
    },
    user: {
      username: os.userInfo().username,
      homedir: os.homedir(),
      tempdir: os.tmpdir()
    },
    memory: {
      total: formatBytes(os.totalmem()),
      free: formatBytes(os.freemem()),
      usage: `${((1 - os.freemem() / os.totalmem()) * 100).toFixed(2)}%`
    },
    cpu: {
      model: os.cpus()[0].model,
      cores: os.cpus().length,
      speed: `${os.cpus()[0].speed} MHz`
    }
  };

  return info;
}

function formatUptime(seconds) {
  const days = Math.floor(seconds / (60 * 60 * 24));
  const hours = Math.floor((seconds % (60 * 60 * 24)) / (60 * 60));
  const minutes = Math.floor((seconds % (60 * 60)) / 60);
  const secs = Math.floor(seconds % 60);

  return `${days}d ${hours}h ${minutes}m ${secs}s`;
}

function formatBytes(bytes) {
  const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
  if (bytes === 0) return '0 Bytes';
  const i = parseInt(Math.floor(Math.log(bytes) / Math.log(1024)));
  return `${(bytes / Math.pow(1024, i)).toFixed(2)} ${sizes[i]}`;
}

// Display the system information dashboard
const systemInfo = getSystemInfo();
console.log('======= SYSTEM INFORMATION DASHBOARD =======');
console.log(JSON.stringify(systemInfo, null, 2));

// Display in a more formatted way
console.log('\n======= FORMATTED SYSTEM INFORMATION =======');
console.log(`OS: ${systemInfo.os.type} (${systemInfo.os.platform} ${systemInfo.os.architecture})`);
console.log(`Version: ${systemInfo.os.release}`);
console.log(`Hostname: ${systemInfo.os.hostname}`);
console.log(`Uptime: ${systemInfo.os.uptime}`);
console.log(`User: ${systemInfo.user.username}`);
console.log(`Home Directory: ${systemInfo.user.homedir}`);
console.log(`CPU: ${systemInfo.cpu.model}`);
console.log(`Cores: ${systemInfo.cpu.cores}`);
console.log(`Speed: ${systemInfo.cpu.speed}`);
console.log(`Memory Total: ${systemInfo.memory.total}`);
console.log(`Memory Free: ${systemInfo.memory.free}`);
console.log(`Memory Usage: ${systemInfo.memory.usage}`);

const os = require('os');

function monitorResources() {
  console.clear(); // Clear console for a cleaner display

  const now = new Date().toLocaleTimeString();
  console.log(`======= RESOURCE MONITOR (${now}) =======`);

  // CPU Usage
  const cpus = os.cpus();
  console.log(`\nCPU Cores: ${cpus.length}`);

  // Calculate CPU usage (this is approximate since we need two measurements)
  const cpuUsage = cpus.map((cpu, index) => {
    const total = Object.values(cpu.times).reduce((acc, tv) => acc + tv, 0);
    const idle = cpu.times.idle;
    const usage = ((total - idle) / total * 100).toFixed(1);
    return `Core ${index}: ${usage}% used`;
  });

  console.log(cpuUsage.join('\n'));

  // Memory Usage
  const totalMem = os.totalmem();
  const freeMem = os.freemem();
  const usedMem = totalMem - freeMem;

  console.log('\nMemory Usage:');
  console.log(`Total: ${formatBytes(totalMem)}`);
  console.log(`Used: ${formatBytes(usedMem)} (${(usedMem / totalMem * 100).toFixed(1)}%)`);
  console.log(`Free: ${formatBytes(freeMem)} (${(freeMem / totalMem * 100).toFixed(1)}%)`);

  // System Uptime
  console.log(`\nSystem Uptime: ${formatUptime(os.uptime())}`);

  // Process Info
  console.log('\nProcess Information:');
  console.log(`PID: ${process.pid}`);
  console.log(`Memory Usage: ${formatBytes(process.memoryUsage().rss)}`);
  console.log(`User: ${os.userInfo().username}`);
}

function formatBytes(bytes) {
  const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
  if (bytes === 0) return '0 Bytes';
  const i = parseInt(Math.floor(Math.log(bytes) / Math.log(1024)));
  return `${(bytes / Math.pow(1024, i)).toFixed(2)} ${sizes[i]}`;
}

function formatUptime(seconds) {
  const days = Math.floor(seconds / (60 * 60 * 24));
  const hours = Math.floor((seconds % (60 * 60 * 24)) / (60 * 60));
  const minutes = Math.floor((seconds % (60 * 60)) / 60);
  const secs = Math.floor(seconds % 60);

  return `${days}d ${hours}h ${minutes}m ${secs}s`;
}

// Initial display
monitorResources();

// Update every second (note: in a real application, you might not want
// to update this frequently as it uses CPU resources)
const intervalId = setInterval(monitorResources, 1000);

// In a real application, you would need to handle cleanup:
// clearInterval(intervalId);

// For this example, we'll run for 10 seconds then stop
console.log('Monitor will run for 10 seconds...');
setTimeout(() => {
  clearInterval(intervalId);
  console.log('\nResource monitoring stopped.');
}, 10000);

const os = require('os');
const fs = require('fs');
const path = require('path');

// Function to determine a good location for app data based on the OS
function getAppDataPath(appName) {
  const platform = os.platform();

  let appDataPath;

  switch (platform) {
    case 'win32': // Windows
      appDataPath = path.join(process.env.APPDATA || '', appName);
      break;
    case 'darwin': // macOS
      appDataPath = path.join(os.homedir(), 'Library', 'Application Support', appName);
      break;
    case 'linux': // Linux
      appDataPath = path.join(os.homedir(), '.config', appName);
      break;
    default: // Fallback for other platforms
      appDataPath = path.join(os.homedir(), `.${appName}`);
  }

  return appDataPath;
}

// Function to get appropriate command based on OS
function getOpenCommand() {
  const platform = os.platform();

  switch (platform) {
    case 'win32': // Windows
      return 'start';
    case 'darwin': // macOS
      return 'open';
    default: // Linux and others
      return 'xdg-open';
  }
}

// Example usage
const appName = 'myapp';
const appDataPath = getAppDataPath(appName);
const openCommand = getOpenCommand();

console.log(`OS Platform: ${os.platform()}`);
console.log(`OS Type: ${os.type()}`);
console.log(`Recommended App Data Path: ${appDataPath}`);
console.log(`Open Command: ${openCommand}`);

// Example of platform-specific behavior
console.log('\nPlatform-Specific Actions:');

if (os.platform() === 'win32') {
  console.log('- Using Windows-specific registry functions');
  console.log('- Setting up Windows service');
} else if (os.platform() === 'darwin') {
  console.log('- Using macOS keychain for secure storage');
  console.log('- Setting up launchd agent');
} else if (os.platform() === 'linux') {
  console.log('- Using Linux systemd for service management');
  console.log('- Setting up dbus integration');
}

// Example of checking for available memory and adjusting behavior
const availableMemGB = os.freemem() / (1024 * 1024 * 1024);
console.log(`\nAvailable Memory: ${availableMemGB.toFixed(2)} GB`);

if (availableMemGB < 0.5) {
  console.log('Low memory mode activated: reducing cache size and disabling features');
} else if (availableMemGB > 4) {
  console.log('High memory mode activated: increasing cache size and enabling all features');
} else {
  console.log('Standard memory mode activated: using default settings');
}

// Example of CPU core detection for parallel processing
const cpuCount = os.cpus().length;
console.log(`\nCPU Cores: ${cpuCount}`);

const recommendedWorkers = Math.max(1, cpuCount - 1); // Leave one core for the system
console.log(`Recommended worker processes: ${recommendedWorkers}`);